#pragma once

#include <nlohmann/json.hpp>
using json = nlohmann::json;

namespace WD {
    // 相机信息
    struct CameraInfo
    {
        std::string sn;                // 相机的sn号（编号）
        std::string model;             // 相机的型号
        std::string mac_addr;          // 相机的mac地址
        std::string ip;                // 相机的ip
        int ws_http_port;      // 相机http端口
        bool ws_need_secret;    // 相机是否需要密码
        std::string connect_client_ip; // 连接相机的客户端IP
        std::string version;           // 固件版本号
    };


    // 故障监测信息
    struct DiagnosticsInfo
    {
        std::string last_error;                     // 错误码
        int trigger_count;                          // 外触发数量
        int average_bitrate;                        // 传输速率 单位BIT 除以8 除以1024 除以1024 等于M
        std::vector<int> queue_state_List;          // 各队列缓冲队列
        std::vector<int> frame_count_List;          // 拍摄帧数队列
        std::vector<std::string> module_state_List; // 各镜头连接状态
    };

    // -----------------------
    // JSON-RPC 方法名宏定义
    // -----------------------
    #define RPC_CONFIG_OUTPUT "config_output"
    #define RPC_SET_PPS_CONFIG "set_pps_config"
    #define RPC_SET_PPS_ENABLE "set_pps_enable"
    #define RPC_SET_GPS_CONFIG "set_gps_config"
    #define RPC_SET_GPS_ENABLE "set_gps_enable"
    #define RPC_SET_IP "set_ip"
    #define RPC_QUERY_CAMERA "query_camera"
    #define RPC_START_STREAM "start_stream"
    #define RPC_STOP_STREAM "stop_stream"
    #define RPC_MODE_SELECT_EXEC "mode_select_exec"
    #define RPC_ID_100 "100"
 

    // -----------------------
    // IP 配置参数结构体
    // -----------------------
    struct IpConfigParams{
        std::string ip;
        std::string mask;
        std::string gateway;
        std::string dns;

        json to_json() const {
            return json{
                {"ip", ip},
                {"mask", mask},
                {"gateway", gateway},
                {"dns", dns},
            };
        }

    };

    inline void from_json(const json& j, IpConfigParams& p) {
        j.at("ip").get_to(p.ip);
        j.at("mask").get_to(p.mask);
        j.at("gateway").get_to(p.gateway);
        j.at("dns").get_to(p.dns);
    }

    // -----------------------
    // 图像输出参数结构体
    // -----------------------
    struct ImageOutParams {
        std::string type;
        bool enable_image_capture_notify;
        int w;
        int h;
        int fps;
        bool stitching;
        int num;
        int burst;
        std::string template_type;
        bool stabilization;
        std::string overlay_image_name;
        int overlay_location;
        int overlay_range;

        json to_json() const {
            return {
                {"type", type},
                {"enable_image_capture_notify", enable_image_capture_notify},
                {"w", w},
                {"h", h},
                {"fps", fps},
                {"stitching", stitching},
                {"num", num},
                {"burst", burst},
                {"template", template_type},
                {"stabilization", stabilization},
                {"overlay_image_name", overlay_image_name},
                {"overlay_location", overlay_location},
                {"overlay_range", overlay_range}
            };
        }
    };

    // from_json 函数支持 JSON -> ImageOutParams
    inline void from_json(const json& j, ImageOutParams& p) {
        j.at("type").get_to(p.type);
        j.at("enable_image_capture_notify").get_to(p.enable_image_capture_notify);
        j.at("w").get_to(p.w);
        j.at("h").get_to(p.h);
        j.at("fps").get_to(p.fps);
        j.at("stitching").get_to(p.stitching);
        j.at("num").get_to(p.num);
        j.at("burst").get_to(p.burst);
        j.at("template").get_to(p.template_type);
        j.at("stabilization").get_to(p.stabilization);
        j.at("overlay_image_name").get_to(p.overlay_image_name);
        j.at("overlay_location").get_to(p.overlay_location);
        j.at("overlay_range").get_to(p.overlay_range);
    }

    // -----------------------
    // GPS 参数结构体
    // -----------------------
    struct GpsParams {
        bool enable_notify;
        int64_t baudrate;
        int sync_mode;

        json to_json() const {
            return {
                {"enable_notify", enable_notify},
                {"baudrate", baudrate},
                {"sync_mode", sync_mode}
            };
        }
    };

    inline void from_json(const json& j, GpsParams& p) {
        j.at("enable_notify").get_to(p.enable_notify);
        j.at("baudrate").get_to(p.baudrate);
        j.at("sync_mode").get_to(p.sync_mode);
    }

    // -----------------------
    // PPS 参数结构体
    // -----------------------
    struct PpsConfigParams {
        bool enable_notify = true;
        int64_t interval;
        int64_t tolerance;
        int verify;
        std::string template_type;
        int polarity;

        json to_json() const {
            return {
                {"enable_notify", enable_notify},
                {"interval", interval},
                {"tolerance", tolerance},
                {"verify", verify},
                {"template", template_type},
                {"polarity", polarity}
            };
        }
    };

    inline void from_json(const json& j, PpsConfigParams& p) {
        j.at("enable_notify").get_to(p.enable_notify);
        j.at("interval").get_to(p.interval);
        j.at("tolerance").get_to(p.tolerance);
        j.at("verify").get_to(p.verify);
        j.at("template").get_to(p.template_type);
        j.at("polarity").get_to(p.polarity);
    }

    // -----------------------
    // PPS 启用参数（快捷函数）
    // -----------------------
    inline json makeEnableJson(bool enable) {
        return {
            {"enable", enable}
        };
    }

} // namespace WD
